home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / binutils.7 / binutils / binutils-2.7 / etc / cfg-paper.info next >
Encoding:
GNU Info File  |  1996-07-15  |  27.8 KB  |  660 lines
  1. This is Info file cfg-paper.info, produced by Makeinfo-1.55 from the
  2. input file ./cfg-paper.texi.
  3.  
  4.    This document attempts to describe the general concepts behind
  5. configuration of the GNU Development Tools.  It also discusses common
  6. usage.
  7.  
  8.    Copyright (C) 1991, 1992, 1994 Cygnus Support Permission is granted
  9. to make and distribute verbatim copies of this manual provided the
  10. copyright notice and this permission notice are preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided that
  14. the entire resulting derived work is distributed under the terms of a
  15. permission notice identical to this one.
  16.  
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions, except that this permission notice may be stated in a
  20. translation approved by Cygnus Support.
  21.  
  22. START-INFO-DIR-ENTRY
  23. * configuration: (cfg-paper).    Some theory on configuring source.
  24. END-INFO-DIR-ENTRY
  25.  
  26. 
  27. File: cfg-paper.info,  Node: Top,  Next: Some Basic Terms,  Prev: (dir),  Up: (dir)
  28.  
  29.    This document attempts to describe the general concepts behind
  30. configuration of the GNU Development Tools.  It also discusses common
  31. usage.
  32.  
  33. * Menu:
  34.  
  35. * Some Basic Terms::        Some Basic Terms
  36. * Specifics.::            Specifics
  37. * Building Development Environments::  Building Development Environments
  38. * A Walk Through::        A Walk Through
  39. * Final Notes::            Final Notes
  40. * Index::            Index
  41.  
  42.  -- The Detailed Node Listing --
  43.  
  44. Some Basic Terms
  45.  
  46. * Host Environments::        Host Environments
  47. * Configuration Time Options::    Configuration Time Options
  48.  
  49. A Walk Through
  50.  
  51. * Native Development Environments::  Native Development Environments
  52. * Emulation Environments::    Emulation Environments
  53. * Simple Cross Environments::    Simple Cross Environments
  54. * Crossing Into Targets::    Crossing Into Targets
  55. * Canadian Cross::        Canadian Cross
  56.  
  57. Final Notes
  58.  
  59. * Hacking Configurations::    Hacking Configurations
  60.  
  61. 
  62. File: cfg-paper.info,  Node: Some Basic Terms,  Next: Specifics.,  Prev: Top,  Up: Top
  63.  
  64. Some Basic Terms
  65. ****************
  66.  
  67.    There are a lot of terms that are frequently used when discussing
  68. development tools.  Most of the common terms have been used for many
  69. different concepts such that their meanings have become ambiguous to the
  70. point of being confusing.  Typically, we only guess at their meanings
  71. from context and we frequently guess wrong.
  72.  
  73.    This document uses very few terms by comparison.  The intent is to
  74. make the concepts as clear as possible in order to convey the usage and
  75. intent of these tools.
  76.  
  77.    *Programs* run on *machines*.  Programs are very nearly always
  78. written in *source*.  Programs are *built* from source.  *Compilation*
  79. is a process that is frequently, but not always, used when building
  80. programs.
  81.  
  82. * Menu:
  83.  
  84. * Host Environments::        Host Environments
  85. * Configuration Time Options::    Configuration Time Options
  86.  
  87. 
  88. File: cfg-paper.info,  Node: Host Environments,  Next: Configuration Time Options,  Prev: Some Basic Terms,  Up: Some Basic Terms
  89.  
  90. Host Environments
  91. =================
  92.  
  93.    In this document, the word *host* refers to the environment in which
  94. the source in question will be compiled.  *host* and *host name* have
  95. nothing to do with the proper name of your host, like *ucbvax*,
  96. *prep.ai.mit.edu* or *att.com*.  Instead they refer to things like
  97. *sun4* and *dec3100*.
  98.  
  99.    Forget for a moment that this particular directory of source is the
  100. source for a development environment.  Instead, pretend that it is the
  101. source for a simpler, more mundane, application, say, a desk calculator.
  102.  
  103.    Source that can be compiled in more than one environment, generally
  104. needs to be set up for each environment explicitly.  Here we refer to
  105. that process as configuration.  That is, we configure the source for a
  106. host.
  107.  
  108.    For example, if we wanted to configure our mythical desk calculator
  109. to compile on a SparcStation, we might configure for host sun4.  With
  110. our configuration system:
  111.  
  112.      cd desk-calculator ; ./configure sun4
  113.  
  114. does the trick.  `configure' is a shell script that sets up Makefiles,
  115. subdirectories, and symbolic links appropriate for compiling the source
  116. on a sun4.
  117.  
  118.    The *host* environment does not necessarily refer to the machine on
  119. which the tools are built.  It is possible to provide a sun3 development
  120. environment on a sun4.  If we wanted to use a cross compiler on the sun4
  121. to build a program intended to be run on a sun3, we would configure the
  122. source for sun3.
  123.  
  124.      cd desk-calculator ; ./configure sun3
  125.  
  126. The fact that we are actually building the program on a sun4 makes no
  127. difference if the sun3 cross compiler presents an environment that looks
  128. like a sun3 from the point of view of the desk calculator source code.
  129. Specifically, the environment is a sun3 environment if the header files,
  130. predefined symbols, and libraries appear as they do on a sun3.
  131.  
  132.    Nor does the host environment refer to the the machine on which the
  133. program to be built will run.  It is possible to provide a sun3
  134. emulation environment on a sun4 such that programs built in a sun3
  135. development environment actually run on the sun4.  This technique is
  136. often used within individual programs to remedy deficiencies in the host
  137. operating system.  For example, some operating systems do not provide
  138. the `bcopy' function and so it is emulated using the `memcpy' funtion.
  139.  
  140.    Host environment simply refers to the environment in which the
  141. program will be built from the source.
  142.  
  143. 
  144. File: cfg-paper.info,  Node: Configuration Time Options,  Prev: Host Environments,  Up: Some Basic Terms
  145.  
  146. Configuration Time Options
  147. ==========================
  148.  
  149.    Many programs have compile time options.  That is, features of the
  150. program that are either compiled into the program or not based on a
  151. choice made by the person who builds the program.  We refer to these as
  152. *configuration options*.  For example, our desk calculator might be
  153. capable of being compiled into a program that either uses infix notation
  154. or postfix as a configuration option.  For a sun3, to choose infix you
  155. might use:
  156.  
  157.      ./configure sun3 --enable-notation=infix
  158.  
  159. while for a sun4 with postfix you might use:
  160.  
  161.      ./configure sun4 --enable-notation=postfix
  162.  
  163.    If we wanted to build both at the same time, the intermediate pieces
  164. used in the build process must be kept separate.
  165.  
  166.      mkdir ../objdir.sun4
  167.      (cd ../objdir.sun4 ; ../configure sun4 --enable-notation=postfix --srcdir=../src)
  168.      mkdir ../objdir.sun3
  169.      (cd ../objdir.sun3 ; ../configure sun3 --enable-notation=infix --srcdir=../src)
  170.  
  171. will create subdirectories for the intermediate pieces of the sun4 and
  172. sun3 configurations.  This is necessary as previous systems were only
  173. capable of one configuration at a time.  Otherwise, a second
  174. configuration would write over the first.  We've chosen to retain this
  175. behaviour so the obj directories and the `--srcdir' configuration
  176. option are necessary to get the new behaviour.  The order of the
  177. arguments doesn't matter.  There should be exactly one argument without
  178. a leading `-' and that argument will be assumed to be the host name.
  179.  
  180.    From here on the examples will assume that you want to build the
  181. tools *in place* and won't show the `--srcdir' option, but remember
  182. that it is available.
  183.  
  184.    In order to actually install the program, the configuration system
  185. needs to know where you would like the program installed.  The default
  186. location is `/usr/local'.  We refer to this location as `$(prefix)'.
  187. All user visible programs will be installed in ``$(prefix)'/bin'.  All
  188. other programs and files will be installed in a subdirectory of
  189. ``$(prefix)'/lib'.
  190.  
  191.    You can only change `$(prefix)' as a configuration time option.
  192.  
  193.      ./configure sun4 --enable-notation=postfix --prefix=/local
  194.  
  195. Will configure the source such that:
  196.  
  197.      make install
  198.  
  199. will put its programs in `/local/bin' and `/local/lib/gcc'.  If you
  200. change `$(prefix)' after building the source, you will need to:
  201.  
  202.      make clean
  203.  
  204. before the change will be propogated properly.  This is because some
  205. tools need to know the locations of other tools.
  206.  
  207.    With these concepts in mind, we can drop the desk calculator example
  208. and move on to the application that resides in these directories,
  209. namely, the source to a development environment.
  210.  
  211. 
  212. File: cfg-paper.info,  Node: Specifics.,  Next: Building Development Environments,  Prev: Some Basic Terms,  Up: Top
  213.  
  214. Specifics
  215. *********
  216.  
  217.    The GNU Development Tools can be built on a wide variety of hosts.
  218. So, of course, they must be configured.  Like the last example,
  219.  
  220.      ./configure sun4 --prefix=/local
  221.      ./configure sun3 --prefix=/local
  222.  
  223. will configure the source to be built in subdirectories, in order to
  224. keep the intermediate pieces separate, and to be installed in `/local'.
  225.  
  226.    When built with suitable development environments, these will be
  227. native tools.  We'll explain the term *native* later.
  228.  
  229. 
  230. File: cfg-paper.info,  Node: Building Development Environments,  Next: A Walk Through,  Prev: Specifics.,  Up: Top
  231.  
  232. Building Development Environments
  233. *********************************
  234.  
  235.    The GNU development tools can not only be built in a number of host
  236. development environments, they can also be configured to create a
  237. number of different development environments on each of those hosts.
  238. We refer to a specific development environment created as a *target*.
  239. That is, the word *target* refers to the development environment
  240. produced by compiling this source and installing the resulting programs.
  241.  
  242.    For the GNU development tools, the default target is the same as the
  243. host.  That is, the development environment produced is intended to be
  244. compatible with the environment used to build the tools.
  245.  
  246.    In the example above, we created two configurations, one for sun4 and
  247. one for sun3.  The first configuration is expecting to be built in a
  248. sun4 development environment, to create a sun4 development environment.
  249. It doesn't necessarily need to be built on a sun4 if a sun4 development
  250. environment is available elsewhere.  Likewise, if the available sun4
  251. development environment produces executables intended for something
  252. other than sun4, then the development environment built from this sun4
  253. configuration will run on something other than a sun4.  From the point
  254. of view of the configuration system and the GNU development tools
  255. source, this doesn't matter.  What matters is that they will be built in
  256. a sun4 environment.
  257.  
  258.    Similarly, the second configuration given above is expecting to be
  259. built in a sun3 development environment, to create a sun3 development
  260. environment.
  261.  
  262.    The development environment produced is a configuration time option,
  263. just like `$(prefix)'.
  264.  
  265.      ./configure sun4 --prefix=/local --target=sun3
  266.      ./configure sun3 --prefix=/local --target=sun4
  267.  
  268.    In this example, like before, we create two configurations.  The
  269. first is intended to be built in a sun4 environment, in subdirectories,
  270. to be installed in `/local'.  The second is intended to be built in a
  271. sun3 environment, in subdirectories, to be installed in `/local'.
  272.  
  273.    Unlike the previous example, the first configuration will produce a
  274. sun3 development environment, perhaps even suitable for building the
  275. second configuration.  Likewise, the second configuration will produce
  276. a sun4 development environment, perhaps even suitable for building the
  277. first configuration.
  278.  
  279.    The development environment used to build these configurations will
  280. determine the machines on which the resulting development environments
  281. can be used.
  282.  
  283. 
  284. File: cfg-paper.info,  Node: A Walk Through,  Next: Final Notes,  Prev: Building Development Environments,  Up: Top
  285.  
  286. A Walk Through
  287. **************
  288.  
  289. * Menu:
  290.  
  291. * Native Development Environments::  Native Development Environments
  292. * Emulation Environments::    Emulation Environments
  293. * Simple Cross Environments::    Simple Cross Environments
  294. * Crossing Into Targets::    Crossing Into Targets
  295. * Canadian Cross::        Canadian Cross
  296.  
  297. 
  298. File: cfg-paper.info,  Node: Native Development Environments,  Next: Emulation Environments,  Prev: A Walk Through,  Up: A Walk Through
  299.  
  300. Native Development Environments
  301. ===============================
  302.  
  303.    Let us assume for a moment that you have a sun4 and that with your
  304. sun4 you received a development environment.  This development
  305. environment is intended to be run on your sun4 to build programs that
  306. can be run on your sun4.  You could, for instance, run this development
  307. environment on your sun4 to build our example desk calculator program.
  308. You could then run the desk calculator program on your sun4.
  309.  
  310.    The resulting desk calculator program is referred to as a *native*
  311. program.  The development environment itself is composed of native
  312. programs that, when run, build other native programs.  Any other program
  313. is referred to as *foreign*.  Programs intended for other machines are
  314. foreign programs.
  315.  
  316.    This type of development environment, which is by far the most
  317. common, is refered to as *native*.  That is, a native development
  318. environment runs on some machine to build programs for that same
  319. machine.  The process of using a native development environment to
  320. build native programs is called a *native* build.
  321.  
  322.      ./configure sun4
  323.  
  324. will configure this source such that when built in a sun4 development
  325. environment, with a development environment that builds programs
  326. intended to be run on sun4 machines, the programs built will be native
  327. programs and the resulting development environment will be a native
  328. development environment.
  329.  
  330.    The development system that came with your sun4 is one such
  331. environment.  Using it to build the GNU Development Tools is a very
  332. common activity and the resulting development environment is quite
  333. popular.
  334.  
  335.      make all
  336.  
  337. will build the tools as configured and will assume that you want to use
  338. the native development environment that came with your machine.
  339.  
  340.    Using a development environment to build a development environment is
  341. called *bootstrapping*.  The release of the GNU Development Tools is
  342. capable of bootstrapping itself.  This is a very powerful feature that
  343. we'll return to later.  For now, let's pretend that you used the native
  344. development environment that came with your sun4 to bootstrap the
  345. release and let's call the new development environment *stage1*.
  346.  
  347.    Why bother?  Well, most people find that the GNU development
  348. environment builds programs that run faster and take up less space than
  349. the native development environments that came with their machines.  Some
  350. people didn't get development environments with their machines and some
  351. people just like using the GNU tools better than using other tools.
  352.  
  353.    While you're at it, if the GNU tools produce better programs, maybe
  354. you should use them to build the GNU tools.  So let's pretend that you
  355. do.  Let's call the new development environment *stage2*.
  356.  
  357.    So far you've built a development environment, stage1, and you've
  358. used stage1 to build a new, faster and smaller development environment,
  359. stage2, but you haven't run any of the programs that the GNU tools have
  360. built.  You really don't yet know if these tools work.  Do you have any
  361. programs built with the GNU tools?  Yes, you do.  stage2.  What does
  362. that program do?  It builds programs.  Ok, do you have any source handy
  363. to build into a program?  Yes, you do.  The GNU tools themselves.  In
  364. fact, if you use stage2 to build the GNU tools again the resulting
  365. programs should be identical to stage2.  Let's pretend that you do and
  366. call the new development environment *stage3*.
  367.  
  368.    You've just completed what's called a *three stage boot*.  You now
  369. have a small, fast, somewhat tested, development environment.
  370.  
  371.      make bootstrap
  372.  
  373. will do a three stage boot across all tools and will compare stage2 to
  374. stage3 and complain if they are not identical.
  375.  
  376.    Once built,
  377.  
  378.      make install
  379.  
  380. will install the development environment in the default location, or in
  381. `$(prefix)' if you specified an alternate when you configured.
  382.  
  383.    Any development environment that is not a native development
  384. environment is refered to as a *cross* development environment.  There
  385. are many different types of cross development environments but most
  386. fall into one of three basic categories.
  387.  
  388. 
  389. File: cfg-paper.info,  Node: Emulation Environments,  Next: Simple Cross Environments,  Prev: Native Development Environments,  Up: A Walk Through
  390.  
  391. Emulation Environments
  392. ======================
  393.  
  394.    The first category of cross development environment is called
  395. *emulation*.  There are two primary types of emulation, but both types
  396. result in programs that run on the native host.
  397.  
  398.    The first type is *software emulation*.  This form of cross
  399. development environment involves a native program that when run on the
  400. native host, is capable of interpreting, and in most aspects running, a
  401. program intended for some other machine.  This technique is typically
  402. used when the other machine is either too expensive, too slow, too fast,
  403. or not available, perhaps because it hasn't yet been built.  The native,
  404. interpreting program is called a *software emulator*.
  405.  
  406.    The GNU Development Tools do not currently include any software
  407. emulators.  Some do exist and the GNU Development Tools can be
  408. configured to create simple cross development environments for with
  409. these emulators.  More on this later.
  410.  
  411.    The second type of emulation is when source intended for some other
  412. development environment is built into a program intended for the native
  413. host.  The concepts of operating system universes and hosted operating
  414. systems are two such development environments.
  415.  
  416. 
  417. File: cfg-paper.info,  Node: Simple Cross Environments,  Next: Crossing Into Targets,  Prev: Emulation Environments,  Up: A Walk Through
  418.  
  419. Simple Cross Environments
  420. =========================
  421.  
  422.      ./configure sun4 --target=a29k
  423.  
  424. will configure the tools such that when compiled in a sun4 development
  425. environment the resulting development environment can be used to create
  426. programs intended for an a29k.  Again, this does not necessarily mean
  427. that the new development environment can be run on a sun4.  That would
  428. depend on the development environment used to build these tools.
  429.  
  430.    Earlier you saw how to configure the tools to build a native
  431. development environment, that is, a development environment that runs
  432. on your sun4 and builds programs for your sun4.  Let's pretend that you
  433. use stage3 to build this simple cross configuration and let's call the
  434. new development environment gcc-a29k.  Remember that this is a native
  435. build.  Gcc-a29k is a collection of native programs intended to run on
  436. your sun4.  That's what stage3 builds, programs for your sun4.
  437. Gcc-a29k represents an a29k development environment that builds
  438. programs intended to run on an a29k.  But, remember, gcc-a29k runs on
  439. your sun4.  Programs built with gcc-a29k will run on your sun4 only
  440. with the help of an appropriate software emulator.
  441.  
  442.    Building gcc-a29k is also a bootstrap but of a slightly different
  443. sort.  We call gcc-a29k a *simple cross* environment and using gcc-a29k
  444. to build a program intended for a29k is called *crossing to* a29k.
  445. Simple cross environments are the second category of cross development
  446. environments.
  447.  
  448. 
  449. File: cfg-paper.info,  Node: Crossing Into Targets,  Next: Canadian Cross,  Prev: Simple Cross Environments,  Up: A Walk Through
  450.  
  451. Crossing Into Targets
  452. =====================
  453.  
  454.      ./configure a29k --target=a29k
  455.  
  456. will configure the tools such that when compiled in an a29k development
  457. environment, the resulting development environment can be used to create
  458. programs intended for an a29k.  Again, this does not necessarily mean
  459. that the new development environment can be run on an a29k.  That would
  460. depend on the development environment used to build these tools.
  461.  
  462.    If you've been following along this walk through, then you've already
  463. built an a29k environment, namely gcc-a29k.  Let's pretend you use
  464. gcc-a29k to build the current configuration.
  465.  
  466.    Gcc-a29k builds programs intended for the a29k so the new development
  467. environment will be intended for use on an a29k.  That is, this new gcc
  468. consists of programs that are foreign to your sun4.  They cannot be run
  469. on your sun4.
  470.  
  471.    The process of building this configuration is a another bootstrap.
  472. This bootstrap is also a cross to a29k.  Because this type of build is
  473. both a bootstrap and a cross to a29k, it is sometimes referred to as a
  474. *cross into* a29k.  This new development environment isn't really a
  475. cross development environment at all.  It is intended to run on an a29k
  476. to produce programs for an a29k.  You'll remember that this makes it, by
  477. definition, an a29k native compiler.  *Crossing into* has been
  478. introduced here not because it is a type of cross development
  479. environment, but because it is frequently mistaken as one.  The process
  480. is *a cross* but the resulting development environment is a native
  481. development environment.
  482.  
  483.    You could not have built this configuration with stage3, because
  484. stage3 doesn't provide an a29k environment.  Instead it provides a sun4
  485. environment.
  486.  
  487.    If you happen to have an a29k lying around, you could now use this
  488. fresh development environment on the a29k to three-stage these tools
  489. all over again.  This process would look just like it did when we built
  490. the native sun4 development environment because we would be building
  491. another native development environment, this one on a29k.
  492.  
  493. 
  494. File: cfg-paper.info,  Node: Canadian Cross,  Prev: Crossing Into Targets,  Up: A Walk Through
  495.  
  496. Canadian Cross
  497. ==============
  498.  
  499.    So far you've seen that our development environment source must be
  500. configured for a specific host and for a specific target.  You've also
  501. seen that the resulting development environment depends on the
  502. development environment used in the build process.
  503.  
  504.    When all four match identically, that is, the configured host, the
  505. configured target, the environment presented by the development
  506. environment used in the build, and the machine on which the resulting
  507. development environment is intended to run, then the new development
  508. environment will be a native development environment.
  509.  
  510.    When all four match except the configured host, then we can assume
  511. that the development environment used in the build is some form of
  512. library emulation.
  513.  
  514.    When all four match except for the configured target, then the
  515. resulting development environment will be a simple cross development
  516. environment.
  517.  
  518.    When all four match except for the host on which the development
  519. environment used in the build runs, the build process is a *cross into*
  520. and the resulting development environment will be native to some other
  521. machine.
  522.  
  523.    Most of the other permutations do exist in some form, but only one
  524. more is interesting to the current discussion.
  525.  
  526.      ./configure a29k --target=sun3
  527.  
  528. will configure the tools such that when compiled in an a29k development
  529. environment, the resulting development environment can be used to create
  530. programs intended for a sun3.  Again, this does not necessarily mean
  531. that the new development environment can be run on an a29k.  That would
  532. depend on the development environment used to build these tools.
  533.  
  534.    If you are still following along, then you have two a29k development
  535. environments, the native development environment that runs on a29k, and
  536. the simple cross that runs on your sun4.  If you use the a29k native
  537. development environment on the a29k, you will be doing the same thing we
  538. did a while back, namely building a simple cross from a29k to sun3.
  539. Let's pretend that instead, you use gcc-a29k, the simple cross
  540. development environment that runs on sun4 but produces programs for
  541. a29k.
  542.  
  543.    The resulting development environment will run on a29k because that's
  544. what gcc-a29k builds, a29k programs.  This development environment will
  545. produce programs for a sun3 because that is how it was configured.  This
  546. means that the resulting development environment is a simple cross.
  547.  
  548.    There really isn't a common name for this process because very few
  549. development environments are capable of being configured this
  550. extensively.  For the sake of discussion, let's call this process a
  551. *Canadian cross*.  It's a three party cross, Canada has a three party
  552. system, hence Canadian Cross.
  553.  
  554. 
  555. File: cfg-paper.info,  Node: Final Notes,  Next: Index,  Prev: A Walk Through,  Up: Top
  556.  
  557. Final Notes
  558. ***********
  559.  
  560.    By *configures*, I mean that links, Makefile, .gdbinit, and
  561. config.status are built.  Configuration is always done from the source
  562. directory.
  563.  
  564. `./configure NAME'
  565.      configures this directory, perhaps recursively, for a single
  566.      host+target pair where the host and target are both NAME.  If a
  567.      previous configuration existed, it will be overwritten.
  568.  
  569. `./configure HOSTNAME --target=TARGETNAME'
  570.      configures this directory, perhaps recursively, for a single
  571.      host+target pair where the host is HOSTNAME and target is
  572.      TARGETNAME.  If a previous configuration existed, it will be
  573.      overwritten.
  574.  
  575. * Menu:
  576.  
  577. * Hacking Configurations::    Hacking Configurations
  578.  
  579. 
  580. File: cfg-paper.info,  Node: Hacking Configurations,  Prev: Final Notes,  Up: Final Notes
  581.  
  582. Hacking Configurations
  583. ======================
  584.  
  585.    The configure scripts essentially do three things, create
  586. subdirectories if appropriate, build a `Makefile', and create links to
  587. files, all based on and tailored to, a specific host+target pair.  The
  588. scripts also create a `.gdbinit' if appropriate but this is not
  589. tailored.
  590.  
  591.    The Makefile is created by prepending some variable definitions to a
  592. Makefile template called `Makefile.in' and then inserting host and
  593. target specific Makefile fragments.  The variables are set based on the
  594. chosen host+target pair and build style, that is, if you use `--srcdir'
  595. or not.  The host and target specific Makefile may or may not exist.
  596.  
  597.    * Makefiles can be edited directly, but those changes will
  598.      eventually be lost.  Changes intended to be permanent for a
  599.      specific host should be made to the host specific Makefile
  600.      fragment.  This should be in `./config/mh-HOST' if it exists.
  601.      Changes intended to be permanent for a specific target should be
  602.      made to the target specific Makefile fragment.  This should be in
  603.      `./config/mt-TARGET' if it exists.  Changes intended to be
  604.      permanent for the directory should be made in `Makefile.in'.  To
  605.      propogate changes to any of these, either use `make Makefile' or
  606.      `./config.status' or re-configure.
  607.  
  608. 
  609. File: cfg-paper.info,  Node: Index,  Prev: Final Notes,  Up: Top
  610.  
  611. Index
  612. *****
  613.  
  614. * Menu:
  615.  
  616. * Bootstrapping:                        Native Development Environments.
  617. * Building:                             Some Basic Terms.
  618. * Canadian Cross:                       Canadian Cross.
  619. * Compilation:                          Some Basic Terms.
  620. * Cross:                                Native Development Environments.
  621. * Crossing into:                        Crossing Into Targets.
  622. * Crossing to:                          Simple Cross Environments.
  623. * Emulation:                            Emulation Environments.
  624. * Foreign:                              Native Development Environments.
  625. * host:                                 Host Environments.
  626. * Machines:                             Some Basic Terms.
  627. * Native:                               Native Development Environments.
  628. * Programs:                             Some Basic Terms.
  629. * Simple cross:                         Simple Cross Environments.
  630. * Software emulation:                   Emulation Environments.
  631. * Software emulator:                    Emulation Environments.
  632. * Source:                               Some Basic Terms.
  633. * Stage1:                               Native Development Environments.
  634. * Stage2:                               Native Development Environments.
  635. * Stage3:                               Native Development Environments.
  636. * Target:                               Building Development Environments.
  637. * Three party cross:                    Canadian Cross.
  638. * Three stage boot:                     Native Development Environments.
  639.  
  640.  
  641. 
  642. Tag Table:
  643. Node: Top1055
  644. Node: Some Basic Terms2009
  645. Node: Host Environments2951
  646. Node: Configuration Time Options5513
  647. Node: Specifics.8316
  648. Node: Building Development Environments8934
  649. Node: A Walk Through11554
  650. Node: Native Development Environments11972
  651. Node: Emulation Environments16221
  652. Node: Simple Cross Environments17579
  653. Node: Crossing Into Targets19188
  654. Node: Canadian Cross21381
  655. Node: Final Notes24208
  656. Node: Hacking Configurations25003
  657. Node: Index26418
  658. 
  659. End Tag Table
  660.